import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

/**
 * 构造函数实现
 *
 * @author Li Sipeng
 * @version 4.0 on   2022-11-12 21:20
 */
public class EntryFile {
    static final int EQUATION_NUM = 50;   // 习题中算式的数量
    static final String addSubFileUrl = "AddSubOperation.txt";  // 生成的混合算式基路径
    static final String addFileUrl = "AddOperation.txt";
    static final String subFileUrl = "SubOperation.txt";
    static final int NUM_PER_LINE = 5;  //每行打印的算式个数

    /**
     * 程序入口
     * */
    public static void main(String[] args) throws Throwable {
        while (1==1){
            printHeader();  //打印头信息
            execute();      //执行程序
        }
    }
    /*
    * 执行程序
    * */
    public static void execute() throws Throwable {
        Scanner sc = null;
        int i = 0;
        try {
            sc = new Scanner(System.in);
            i = sc.nextInt();
        } catch (Exception e) {
            System.out.println("请输入对应的数字奥！");
        }
        switch(i){
            case 1:
                OperationBase obNew = new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                obNew.setManyBinaryOperaiton(EQUATION_NUM,addSubFileUrl,'2');
                obNew.formatAndDisplayExercise(obNew.addSubList,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obNew.formatAndDisplayExercise(obNew.addSubList,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 2:
                OperationBase obNew1 = new OperationBase();  //产生一个文件，并存储指定数量的加法算式到文件（序列化）
                obNew1.setManyBinaryOperaiton(EQUATION_NUM,addFileUrl,'+');
                obNew1.formatAndDisplayExercise(obNew1.addList,NUM_PER_LINE,0); //打印算式，一行5个,0不含有答案
                suspend(true);
                obNew1.formatAndDisplayExercise(obNew1.addList,NUM_PER_LINE,1); //打印算式，一行5个，1含有答案
                break;
            case 3:
                OperationBase obNew2 = new OperationBase();  //产生一个文件，并存储指定数量的加法算式到文件（序列化）
                obNew2.setManyBinaryOperaiton(EQUATION_NUM,subFileUrl,'-');
                obNew2.formatAndDisplayExercise(obNew2.subList,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obNew2.formatAndDisplayExercise(obNew2.subList,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 4:
                OperationBase obOld = new OperationBase();
                OperationBase obf = obOld.getManyBinaryOperaiton(addSubFileUrl);// 反序列化，从已有的文件中读取混合算式
                obf.formatAndDisplayExercise(obf.addSubList,NUM_PER_LINE,0); //打印算式，一行NUM_PER_LINE个
                suspend(true);
                obf.formatAndDisplayExercise(obf.addSubList,NUM_PER_LINE,1); //打印算式，一行NUM_PER_LINE个
                break;
            case 5:
                OperationBase obOld1 = new OperationBase();  //从已有的文件中读取加法算式
                OperationBase obf1 = obOld1.getManyBinaryOperaiton(addFileUrl);
                obf1.formatAndDisplayExercise(obf1.addList,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obf1.formatAndDisplayExercise(obf1.addList,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 6:
                OperationBase obOld2 = new OperationBase();  //从已有的文件中读取加法算式
                OperationBase obf2 = obOld2.getManyBinaryOperaiton(subFileUrl);
                obf2.formatAndDisplayExercise(obf2.subList,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obf2.formatAndDisplayExercise(obf2.subList,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 7:
                System.out.print("请输入将要生成算式的数量：");
                int OpNum = sc.nextInt();
                OperationBase  obNew3= new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                ArrayList<Operation> list = obNew3.createBinaryOperations(OpNum,'2');
                obNew3.formatAndDisplayExercise(list,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obNew3.formatAndDisplayExercise(list,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 8:
                System.out.print("请输入将要生成算式的数量：");
                int OpNum1 = sc.nextInt();
                OperationBase  obNew4= new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                ArrayList<Operation> list1 = obNew4.createBinaryOperations(OpNum1,'+');
                obNew4.formatAndDisplayExercise(list1,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obNew4.formatAndDisplayExercise(list1,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 9:
                System.out.print("请输入将要生成算式的数量：");
                int OpNum2 = sc.nextInt();
                OperationBase  obNew5= new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                ArrayList<Operation> list2 = obNew5.createBinaryOperations(OpNum2,'-');
                obNew5.formatAndDisplayExercise(list2,NUM_PER_LINE,0); //打印算式，一行5个
                suspend(true);
                obNew5.formatAndDisplayExercise(list2,NUM_PER_LINE,1); //打印算式，一行5个
                break;
            case 10:
                OperationBase  obNew6= new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                ArrayList<Operation> list3 = obNew6.createBinaryOperations(10,'2');  //加法算式+，减法-，混合2
                obNew6.formatAndDisplayExercise(list3,NUM_PER_LINE,0); //打印算式，一行5个
                Answers ans = new Answers();
                Timer time= new Timer();
                time.startTimer();
                ans.collectAnswers(list3);  //收集答案
                endTimer(time);
                HashMap rsMap = ans.checkAnswers(list3);  //传入正确算式，检查答案，返回统计结果和错题集到map中
                ans.printResult(rsMap);  //打印统计结果
                ans.printErrorOperations((ArrayList) rsMap.get("errorList"),NUM_PER_LINE,3);  //打印错题
                break;
            case 11:
                OperationBase  obNew11= new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                ArrayList<Operation> list11 = obNew11.createBinaryOperations(10,'+');  //加法算式+，减法-，混合2
                obNew11.formatAndDisplayExercise(list11,NUM_PER_LINE,0); //打印算式，一行5个
                Answers ans11 = new Answers();
                Timer time11 = new Timer();
                time11.startTimer();
                ans11.collectAnswers(list11);  //收集答案
                endTimer(time11);
                HashMap rsMap11 = ans11.checkAnswers(list11);  //传入正确算式，检查答案，返回统计结果和错题集到map中
                ans11.printResult(rsMap11);  //打印统计结果
                ans11.printErrorOperations((ArrayList) rsMap11.get("errorList"),NUM_PER_LINE,3);  //打印错题
                break;
            case 12:
                OperationBase  obNew12= new OperationBase();  //产生一个文件，并存储指定数量的混合算式到文件（序列化）
                ArrayList<Operation> list12 = obNew12.createBinaryOperations(10,'-');  //加法算式+，减法-，混合2
                obNew12.formatAndDisplayExercise(list12,NUM_PER_LINE,0); //打印算式，一行5个
                Answers ans12 = new Answers();
                Timer time12 = new Timer();
                time12.startTimer();
                ans12.collectAnswers(list12);  //收集答案
                endTimer(time12);
                HashMap rsMap12 = ans12.checkAnswers(list12);  //传入正确算式，检查答案，返回统计结果和错题集到map中
                ans12.printResult(rsMap12);  //打印统计结果
                ans12.printErrorOperations((ArrayList) rsMap12.get("errorList"),NUM_PER_LINE,3);  //打印错题
                break;
            default:
                System.out.println("非法输入！");
                break;
        }
    }
    /*
    * 打印头信息
    * */
    public static void printHeader(){
        System.out.println("\n\n生成50道100以内的口算题：");
        System.out.println("1：重新生成加减法混合算式\n" +
                "\t2：重新生成加法算式\n" +
                "\t3：重新生成减法算式\n" +
                "4：从已有的文件中读取混合算式\n" +
                "\t5:从已有的文件中读取加法算式\n" +
                "\t6:从已有的文件中读取减法算式\n" +
                "7：生成指定数量混合算式（无痕模式）\n" +
                "\t8:生成指定数量加法算式（无痕模式）\n" +
                "\t9:生成指定数量减法算式（无痕模式）\n" +
                "10:每日一练（10道加减混合算式）\n" +
                "\t11:每日一练（10道加法算式）\n" +
                "\t12:每日一练（10道减法算式）\n");
        System.out.print("请输入你需要的题目来源：");
    }

    /*
    * 开始作答，开始计时
    * */
    public static void suspend(boolean b){
        Timer time = new Timer();
        time.startTimer();  //开始计时
        if (b){
            Scanner sc = new Scanner(System.in);
            System.out.println("\n开始计时，键入回车结束并查看答案：");
            String str = sc.nextLine();  //读取回车
            endTimer(time);
        }
    }

    public static void endTimer(Timer time){
        time.endTimer();  //暂停时间
        long t = time.coumptedTime();
        System.out.println("-------------耗时"+t/1000+"秒，约"+((t/1000/60)+1)+"分钟--------------");
    }



}
